home *** CD-ROM | disk | FTP | other *** search
/ Resource for Source: C/C++ / Resource for Source - C-C++.iso / codelib6 / v_08_03 / 8n03115a < prev    next >
Encoding:
Text File  |  1995-11-01  |  12.0 KB  |  349 lines
  1. #include "stdlib.h"
  2. #include "stdio.h"
  3. #include "conio.h"
  4. #include "string.h"
  5. #include "graph.fd"
  6. #include "halo.h"
  7.  
  8. #define OK     1
  9. #define FAIL   0
  10. #define TRUE   1
  11. #define FALSE  0
  12.  
  13. #define CMD_DELIMITER " \t\n"
  14. #define VAL_DELIMITER ",\n"
  15. #define TICK_WIDTH    0.025
  16. #define SQRT_2        1.414213562
  17.  
  18. char *cmd_strs[] = {"DATA","COLORS","MODE","ATTRIBUTES","SCALE","LEGEND",
  19.    "FONT","TITLES","DEVICE","PRINTER","COMMENT","END" };
  20. enum cmd_vals { C_DATA, C_COLORS, C_MODE, C_ATTRIBUTES, C_SCALE, C_LEGEND,
  21.    C_FONT, C_TITLES, C_DEVICE, C_PRINTER, C_COMMENT, C_END };
  22.  
  23. #define NUM_CMD_VALS   ((int)C_END)
  24. union udata {
  25.    float fdata[64];      /* Numeric data for commands (e.g. COLORS) */
  26.    char cdata[16][16];   /* String data for commands (e.g. LEGEND)  */
  27.    };
  28.  
  29. typedef struct cmd_data_type {
  30.    union udata d;          /* Commands data is string or numeric    */
  31.    int count;              /* Number of data items found in command */
  32.    } cmd_data_type, *cmd_data_type_p;
  33.  
  34. typedef struct {           /* HALO '88 specific global data         */
  35.    char *device;           /* Name of HALO screen device driver     */
  36.    char *font;             /* Name of HALO stroke font file         */
  37.    float x1,y1,x2,y2;      /* World coordinates rectangle values    */
  38.    int degree_mode;        /* if true use degrees, else radians     */
  39.    int lnstyle;            /* Line style, 1 <= lnstyle <= 10        */
  40.    int lnwidth;            /* Line thickness in pixels, always odd  */
  41.    int maxcolor;           /* Number of colors supported by device  */
  42.    int mode;               /* Device dependent graphics mode        */
  43.    } halo_type;
  44.  
  45. typedef struct {
  46.    float start_x, start_y;     /* Bottom corner of graph draw area  */
  47.    float end_x, end_y;         /* Upper corner of graph draw area   */
  48.    float scale_min, scale_max; /* Y-Axis min and max values         */
  49.    int num_points;             /* Number of points in DATA file     */
  50.    int num_ticks;              /* Number of ticks on the Y-Axis     */
  51.    int num_colors;             /* Number of user-supplied colors    */
  52.    char *legend;               /* User-supplied LEGEND              */
  53.    } graph_type;
  54.  
  55. cmd_data_type cmd_data[NUM_CMD_VALS];
  56. halo_type halo;
  57. graph_type graph;
  58.  
  59. main(argc,argv)
  60. int argc;
  61. char **argv;
  62. {
  63.    char inp_line[128];
  64.    FILE *infile;
  65.  
  66.    if (argc>1) {  /* First argv should be input data file */
  67.       if ((infile=fopen(argv[1],"r")) == NULL) {
  68.          fprintf(stderr,"Error:  can't open %s\n",argv[1]);
  69.          exit(-1);
  70.          }
  71.       }
  72.    else {         /* no data file was given              */
  73.       fprintf(stderr,"Usage:  graph inputfile\n");
  74.       exit(-1);
  75.       }
  76.  
  77.    memset(cmd_data, 0, sizeof(cmd_data));
  78.  
  79.    while(fgets(inp_line,sizeof(inp_line)-1,infile) != NULL)
  80.       process_graphics_cmd_line(inp_line);
  81.    fclose(infile);
  82.  
  83.    setup_halo_globals();     /* Capture relevant parameters    */
  84.    setup_graph_globals();
  85.    draw_bar_graph();         /* Draw the actual graph          */
  86.    deltcur();                /* Remove text "_" cursor         */
  87.    getch();
  88.    print_graph();            /* Print graph if requested       */
  89.    closegraphics();          /* Close out all devices          */
  90.    return OK;
  91. }
  92.  
  93.  
  94.  
  95. int process_graphics_cmd_line(inp_line)
  96. char *inp_line;
  97. {
  98.    char input[128];
  99.    char *cmd_keywd;
  100.    int found = FALSE;
  101.    int cmd_val;
  102.  
  103.    strcpy(input,inp_line);
  104.    if ((cmd_keywd=strtok(input,CMD_DELIMITER)) == NULL) {
  105.       fprintf(stderr,"Unable to parse to command <%s>\n",inp_line);
  106.       return FAIL;
  107.       }
  108.  
  109.    for (cmd_val=0; cmd_val<=NUM_CMD_VALS; cmd_val++)
  110.       if (stricmp(cmd_strs[cmd_val],cmd_keywd)==0) {
  111.          found = TRUE;
  112.          break;
  113.          }
  114.  
  115.    if (!found) {
  116.       fprintf(stderr,"Keyword <%s> not recognized.\n",cmd_keywd);
  117.       return FAIL;
  118.       }
  119.  
  120.    if (cmd_val <= C_SCALE)
  121.       parse_delimited_number_list(&cmd_data[cmd_val]);
  122.    else
  123.       parse_delimited_string_list(&cmd_data[cmd_val]);
  124.    return OK;
  125. }
  126.  
  127.  
  128.  
  129. void parse_delimited_number_list(data_p)
  130. cmd_data_type *data_p;
  131. {
  132.    int i;
  133.    char *cmd_data;
  134.  
  135.    i = data_p->count;
  136.    while ((cmd_data=strtok(NULL,VAL_DELIMITER)) != NULL)
  137.       data_p->d.fdata[i++] = (float) atof(cmd_data);
  138.    data_p->count = i;
  139. }
  140.  
  141.  
  142.  
  143. void parse_delimited_string_list(data_p)
  144. cmd_data_type_p data_p;
  145. {
  146.    int i;
  147.    char *cmd_data;
  148.  
  149.    i = data_p->count;
  150.    while ((cmd_data=strtok(NULL,VAL_DELIMITER)) != NULL)
  151.       strcpy(data_p->d.cdata[i++],cmd_data);
  152.    data_p->count = i;
  153. }
  154.  
  155.  
  156.  
  157. void setup_halo_globals()
  158. {
  159.    if (cmd_data[C_DEVICE].count)        /* Was there a DEVICE command? */
  160.       halo.device = cmd_data[C_DEVICE].d.cdata[0];
  161.    else                                   /* No, use the default       */
  162.       halo.device = "HALOIBMG.DEV";
  163.    printf("using device <%s>, press any key to start:\n",halo.device);
  164.    getch();
  165.    setdev(halo.device);              /* Initialize the graphics device */
  166.  
  167.    halo.mode = (int) cmd_data[C_MODE].d.fdata[0];
  168.    initgraphics(&halo.mode);             /* Clear screen in given mode */
  169.    halo.degree_mode = 1;
  170.    setdegree(&halo.degree_mode);           /* Use degrees, not radians */
  171.    halo.x1 = (float) 0.0;   halo.y1 = (float) 0.0;
  172.    halo.x2 = (float) 1.0;   halo.y2 = (float) 1.0;
  173.    setworld(&halo.x1,&halo.y1,&halo.x2,&halo.y2); /* World rectangle   */
  174.    inqcrange(&halo.maxcolor );                /* Find max color value  */
  175.    halo.lnwidth = 1;
  176.    setlnwidth(&halo.lnwidth) ;                /* Line width is 1 pixel */
  177.    halo.lnstyle = 1;
  178.    setlnstyle(&halo.lnstyle);                 /* Line style is solid   */
  179.    setcolor(&halo.maxcolor);      /* Max screen color is usually white */
  180.  
  181.    if (cmd_data[C_FONT].count)            /* Was there a FONT command? */
  182.       halo.font = cmd_data[C_FONT].d.cdata[0];
  183.    else                                   /* No, use the default       */
  184.       halo.font = "HALO104.FNT";
  185.    setfont(halo.font);                    /* Load font from disk file  */
  186.    setstclr(&halo.maxcolor,&halo.maxcolor) ;  /* Set stroke text color */
  187. }
  188.  
  189.  
  190. void setup_graph_globals()
  191. {
  192.    float *data_ptr;
  193.    int i;
  194.  
  195.    /* This rectangle is the active drawing area of the global window */
  196.    graph.start_x = (float) 0.1;   graph.end_x = (float) 0.9;
  197.    graph.start_y = (float) 0.15;  graph.end_y = (float) 0.88;
  198.    graph.num_ticks = 10;
  199.    graph.num_points = cmd_data[C_DATA].count;
  200.    graph.num_colors = cmd_data[C_COLORS].count;
  201.    graph.legend = cmd_data[C_LEGEND].d.cdata[0];
  202.  
  203.    if (cmd_data[C_SCALE].count) {  /* User supplied SCALE boundaries */
  204.       graph.scale_min = cmd_data[C_SCALE].d.fdata[0];
  205.       graph.scale_max = cmd_data[C_SCALE].d.fdata[1];
  206.       }
  207.    else { /* No SCALE bounds, use min and max data values for SCALE */
  208.       graph.scale_min = (float) 0.0;
  209.       graph.scale_max = (float) 0.0;
  210.       data_ptr = cmd_data[C_DATA].d.fdata;
  211.       for (i=0; i < graph.num_points; i++, data_ptr++) {
  212.          if (graph.scale_min > *data_ptr)
  213.             graph.scale_min = *data_ptr;  /* New minimum data point */
  214.          if (graph.scale_max < *data_ptr)
  215.             graph.scale_max = *data_ptr;  /* New maximum data point */
  216.          }
  217.       }
  218. }
  219.  
  220.  
  221. void draw_axes(bar_width)
  222. double bar_width;
  223. {
  224.    int i;
  225.    float tick_interval;                  /* Distance between Y-Axis ticks */
  226.    float axis_interval;               /* Y-Axis tick value in scale units */
  227.    float height = (float) 0.10;                     /* Stroke text height */
  228.    float angle = (float) 45.0;               /* Stroke text drawing angle */
  229.    float asp = (float) 1.0;                   /* Stroke text aspect ratio */
  230.    int path = 0;                                      /* Stroke text path */
  231.    float text_height;                   /* Inquired height of text string */
  232.    float text_width;                     /* Inquired width of text String */
  233.    float offse;                                  /* Offset for descenders */
  234.    float x_val, y_val;                       /* General-purpose registers */
  235.    char axis_label[20];                    /* String used to label a tick */
  236.    char *title;                             /* User-specified graph TITLE */
  237.  
  238.    /* draw the legend above the graph */
  239.    setstext(&height,&asp,&path);
  240.    inqstsize(graph.legend,&text_height,&text_width,&offse);
  241.    x_val = (halo.x2-text_width)/2.0;
  242.    y_val = (float) 0.99 - height;
  243.    movtcurabs(&x_val,&y_val);
  244.    stext(graph.legend);
  245.  
  246.    /* draw X and Y axes */
  247.    draw_line(graph.start_x, graph.start_y, graph.end_x, graph.start_y);
  248.    draw_line(graph.start_x, graph.start_y, graph.start_x, graph.end_y);
  249.    tick_interval = (graph.end_y - graph.start_y) / graph.num_ticks;
  250.    axis_interval = (graph.scale_max - graph.scale_min) / graph.num_ticks;
  251.    height = tick_interval * 0.80;  /* text height is 80% of tick dist. */
  252.    setstext(&height,&asp,&path);
  253.  
  254.    /* Draw ticks and label the Y-Axis */
  255.    y_val = graph.start_y;
  256.    for (i=0; i<graph.num_ticks+1; i++) {
  257.       sprintf(axis_label,"%d", (int)(graph.scale_min + axis_interval * i));
  258.       inqstsize(axis_label,&text_height,&text_width,&offse);
  259.       x_val = graph.start_x - 1.5 * TICK_WIDTH - text_width;
  260.       movtcurabs(&x_val,&y_val);
  261.       stext(axis_label);
  262.       draw_line(graph.start_x-TICK_WIDTH,y_val,graph.start_x+TICK_WIDTH,y_val);
  263.       y_val += tick_interval;
  264.       }
  265.  
  266.    /* draw bar labels at a 45-degree angle along the X-Axis */
  267.    setstang(&angle);
  268.    for (i=0; i<graph.num_points; i++) {
  269.       title = cmd_data[C_TITLES].d.cdata[i];
  270.       inqstsize(title,&text_height,&text_width,&offse);
  271.       x_val = graph.start_x + (i+0.5) * bar_width - text_width/SQRT_2;
  272.       y_val = graph.start_y - (text_height*1.25 + text_width/SQRT_2);
  273.       movtcurabs(&x_val,&y_val);
  274.       stext(title);                       /* draw the actual text */
  275.       }
  276. }
  277.  
  278.  
  279. void draw_bar_graph()
  280. {
  281.    float bar_width;                 /* Width of a bar in display units  */
  282.    float bar_height;                /* Height of a bar in display units */
  283.    int bar_color;                   /* Color to draw the bar with       */
  284.    float *data_ptr;                 /* Used to fetch user's DATA        */
  285.    int i;
  286.    int hatch_style;                 /* Hatch style to draw the bar with */
  287.  
  288.    /* draw_legend(); */
  289.  
  290.    data_ptr = cmd_data[C_DATA].d.fdata;      /* 1st data point to plot */
  291.    bar_width = (graph.end_x - graph.start_x) / graph.num_points;
  292.    draw_axes(bar_width);
  293.    for (i=0; i<graph.num_points; i++, data_ptr++) {
  294.       if (graph.num_colors && halo.maxcolor>1) {
  295.          bar_color = (int) cmd_data[C_COLORS].d.fdata[i % graph.num_colors];
  296.          setcolor(&bar_color);
  297.          }
  298.       else {  /* Monochrome display or color display with no COLORS data */
  299.          hatch_style = (i % 4) + 1;
  300.          sethatchstyle(&hatch_style);
  301.          }
  302.       bar_height = (*data_ptr - graph.scale_min) /
  303.           (graph.scale_max - graph.scale_min) * (graph.end_y - graph.start_y);
  304.       draw_bar(graph.start_x+i*bar_width, graph.start_y,
  305.                graph.start_x+(i+1)*bar_width, graph.start_y + bar_height);
  306.       }
  307.  
  308. }
  309.  
  310.  
  311. void print_graph()
  312. {
  313.    char *print_name;
  314.    int print_attr[18];
  315.    int i;
  316.  
  317.    print_name = cmd_data[C_PRINTER].d.cdata[0];
  318.    if (*print_name == '\0')
  319.       return;           /* If no printer specified, do not print */
  320.    setprn(print_name);
  321.    if (cmd_data[C_ATTRIBUTES].count) {  /* Device-specific attribs */
  322.       for (i=0; i < cmd_data[C_ATTRIBUTES].count; i++)
  323.          print_attr[i] = cmd_data[C_ATTRIBUTES].d.fdata[i];
  324.       setpattr(print_attr);
  325.       }
  326.    gprint();
  327. }
  328.  
  329.  
  330. void draw_bar(x1,y1,x2,y2)   /* Draw a bar from (x1,y1) to (x2,y2) */
  331. double x1,y1,x2,y2;
  332. {
  333.    float x1_t,y1_t,x2_t,y2_t;
  334.  
  335.    x1_t = (float)x1; y1_t = (float)y1; x2_t = (float)x2; y2_t = (float)y2;
  336.    bar(&x1_t,&y1_t,&x2_t,&y2_t);
  337. }
  338.  
  339.  
  340. void draw_line(x1,y1,x2,y2)   /* Draw a line from (x1,y1) to (x2,y2) */
  341. double x1,y1,x2,y2;
  342. {
  343.    float x1_t,y1_t,x2_t,y2_t;
  344.  
  345.    x1_t = (float)x1; y1_t = (float)y1; x2_t = (float)x2; y2_t = (float)y2;
  346.    movabs(&x1_t,&y1_t);
  347.    lnabs(&x2_t,&y2_t);
  348. }
  349.